home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / net / omniORB-2.5.0-src.tar.gz / omniORB-2.5.0-src.tar / omniORB_2.5.0 / include / omniORB2 / CORBA.h < prev    next >
C/C++ Source or Header  |  1998-02-20  |  65KB  |  2,471 lines
  1. // -*- Mode: C++; -*-
  2. //                            Package   : omniORB2
  3. // CORBA.h                    Created on: 30/1/96
  4. //                            Author    : Sai Lai Lo (sll)
  5. //
  6. //    Copyright (C) 1996, 1997 Olivetti & Oracle Research Laboratory
  7. //
  8. //    This file is part of the omniORB library
  9. //
  10. //    The omniORB library is free software; you can redistribute it and/or
  11. //    modify it under the terms of the GNU Library General Public
  12. //    License as published by the Free Software Foundation; either
  13. //    version 2 of the License, or (at your option) any later version.
  14. //
  15. //    This library is distributed in the hope that it will be useful,
  16. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18. //    Library General Public License for more details.
  19. //
  20. //    You should have received a copy of the GNU Library General Public
  21. //    License along with this library; if not, write to the Free
  22. //    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
  23. //    02111-1307, USA
  24. //
  25. //
  26. // Description:
  27. //     A complete set of C++ definitions for the CORBA module. The definitions
  28. //    appear within the C++ class named CORBA. This mapping is fully
  29. //      compliant with the CORBA 2.0 specification.
  30. // 
  31.  
  32. /*
  33.  $Log: CORBA.h,v $
  34.  * Revision 1.19  1998/02/20  14:44:44  ewc
  35.  * Changed to compile with aCC on HPUX
  36.  *
  37.  * Revision 1.18  1998/02/03  16:47:09  ewc
  38.  * Updated some interfaces.
  39.  *
  40.  * Revision 1.17  1998/01/27  16:02:34  ewc
  41.  * Added TypeCode and type Any
  42.  *
  43.  Revision 1.16  1997/12/18 17:37:20  sll
  44.  Added (const char*) type casting to help strcpy().
  45.  
  46.  Revision 1.15  1997/12/09 20:35:16  sll
  47.  New members BOA::impl_shutdown, BOA::destroy.
  48.  
  49.  Revision 1.14  1997/08/21 22:20:17  sll
  50.  - String_member copy ctor bug fix.
  51.  - New system exception TRANSACTION_REQUIRED, TRANSACTION_ROLLEDBACK,
  52.    INVALID_TRANSACTION and WRONG_TRANSACTION.
  53.  - Correct ORB_init() signature.
  54.  - CORBA::is_nil(Object_ptr) is now more sympathetic to applications
  55.    treating a nil pointer as a nil object reference.
  56.  
  57.  * Revision 1.13  1997/05/21  15:01:40  sll
  58.  * Added typedef <type>_ptr <type>Ref;
  59.  *
  60.  * Revision 1.12  1997/05/06  16:04:43  sll
  61.  * Public release.
  62.  *
  63. */
  64.  
  65. #ifndef __CORBA_H__
  66. #define __CORBA_H__
  67.  
  68. #include <omniORB2/omniInternal.h>
  69.  
  70. class _OMNIORB2_NTDLL_ CORBA {
  71.  
  72. public:
  73.  
  74. typedef void* Status;
  75.  
  76. ////////////////////////////////////////////////////////////////////////
  77. //                   Primitive types                                  //
  78. ////////////////////////////////////////////////////////////////////////
  79.   
  80. typedef _CORBA_Boolean Boolean;
  81. typedef _CORBA_Char    Char;
  82. typedef _CORBA_Octet   Octet;
  83. typedef _CORBA_Short   Short;
  84. typedef _CORBA_UShort  UShort;
  85. typedef _CORBA_Long    Long;
  86. typedef _CORBA_ULong   ULong;
  87. #ifndef NO_FLOAT
  88. typedef _CORBA_Float   Float;
  89. typedef _CORBA_Double  Double;
  90. #endif
  91.  
  92. ////////////////////////////////////////////////////////////////////////
  93. //                   Type String                                      //
  94. ////////////////////////////////////////////////////////////////////////
  95.   
  96.   static char *string_alloc(ULong len);
  97.   static void string_free(char *);
  98.   static char *string_dup(const char *);
  99.  
  100.  
  101.   class String_member;
  102.   class String_INOUT_arg;
  103.   class String_OUT_arg;
  104.  
  105.   class String_var {
  106.   public:
  107.     typedef char* ptr_t;
  108.  
  109.     inline String_var() {
  110.       _data = 0;
  111.     }
  112.  
  113.     inline String_var(char *p) {
  114.       _data = p;
  115.     }
  116.  
  117.     inline String_var(const char* p) {
  118.       if (p) {
  119.     _data = string_alloc((ULong)(strlen(p)+1));
  120.     strcpy(_data,p);
  121.       }
  122.       else
  123.     _data = 0;
  124.     }
  125.  
  126.     inline String_var(const String_var &s) {
  127.       if ((const char *)s) {
  128.     _data = string_alloc((ULong)(strlen(s)+1));
  129.     strcpy(_data,(const char*)s);
  130.       }
  131.       else {
  132.     _data = 0;
  133.       }
  134.     }
  135.  
  136.     String_var(const String_member &s);
  137.  
  138.     inline ~String_var() {
  139.       if (_data)
  140.     string_free(_data);
  141.     }
  142.  
  143.     inline String_var &operator= (char *p) {
  144.       if (_data) {
  145.     string_free(_data);
  146.     _data = 0;
  147.       }
  148.       _data = p;
  149.       return *this;
  150.     }
  151.  
  152.     inline String_var &operator= (const char *p) {
  153.       if (_data) {
  154.     string_free(_data);
  155.     _data = 0;
  156.       }
  157.       if (p) {
  158.     _data = string_alloc((ULong)(strlen(p)+1));
  159.     strcpy(_data,p);
  160.       }
  161.       return *this;
  162.     }
  163.  
  164.     inline String_var &operator= (const String_var &s) {
  165.       if (_data) {
  166.     string_free(_data);
  167.     _data = 0;
  168.       }
  169.       if ((const char *)s) {
  170.     _data = string_alloc((ULong)(strlen(s)+1));
  171.     strcpy(_data,(const char*)s);
  172.       }
  173.       return *this;
  174.     }
  175.  
  176.     String_var &operator= (const String_member &s);
  177.  
  178.     inline operator char* () const { return _data; }
  179.     inline operator const char* () const { return _data; }
  180.  
  181.     char &operator[] (ULong index);
  182.  
  183.     char operator[] (ULong index) const;
  184.  
  185.     friend class String_INOUT_arg;
  186.     friend class String_OUT_arg;
  187.  
  188.   private:
  189.     char* _data;
  190.   };
  191.  
  192.   // omniORB2 private class
  193.   class String_member
  194.   {
  195.   public:
  196.     typedef char* ptr_t;
  197.     inline String_member() {
  198.       _ptr = 0;
  199.     }
  200.  
  201.     inline ~String_member() {
  202.       if (_ptr) string_free(_ptr);
  203.     }
  204.  
  205.     inline String_member(const String_member &s) {
  206.       _ptr = 0;
  207.       if (s._ptr) {
  208.     _ptr = string_alloc((ULong)(strlen(s._ptr)+1));
  209.     strcpy(_ptr,s._ptr);
  210.       }
  211.     }
  212.  
  213.     inline String_member& operator= (char *s) {
  214.       if (_ptr) {
  215.     string_free(_ptr);
  216.     _ptr = 0;
  217.       }
  218.       _ptr = s;
  219.       return *this;
  220.     }
  221.  
  222.     inline String_member& operator= (const char *s) {
  223.       if (_ptr) {
  224.     string_free(_ptr);
  225.     _ptr = 0;
  226.       }
  227.       if (s) {
  228.     _ptr = string_alloc((ULong)(strlen(s)+1));
  229.     strcpy(_ptr,s);
  230.       }
  231.       return *this;
  232.     }
  233.     
  234.  
  235.     inline String_member& operator= (const String_member & s) {
  236.       if (_ptr) {
  237.     string_free(_ptr);
  238.     _ptr = 0;
  239.       }
  240.       if (s._ptr) {
  241.     _ptr = string_alloc((ULong)(strlen(s._ptr)+1));
  242.     strcpy(_ptr,s._ptr);
  243.       }
  244.       return *this;
  245.     }
  246.  
  247.     String_member& operator= (const String_var & s);
  248.  
  249.     inline operator char* () { return _ptr; }
  250.     inline operator const char*() const { return _ptr; }
  251.  
  252.     char* _ptr;
  253.  
  254.     void operator>>= (NetBufferedStream &s) const;
  255.     void operator<<= (NetBufferedStream &s);
  256.  
  257.     void operator>>= (MemBufferedStream &s) const;
  258.     void operator<<= (MemBufferedStream &s);
  259.     size_t NP_alignedSize(size_t initialoffset) const;
  260.   };
  261.  
  262.   // omniORB2 private class
  263.   class String_INOUT_arg {
  264.   public:
  265.     inline String_INOUT_arg(char*& p) : _data(p) {}
  266.     inline String_INOUT_arg(String_var& p) : _data(p._data) {}
  267.     inline String_INOUT_arg(String_member& p) : _data(p._ptr) {}
  268.     inline ~String_INOUT_arg() {}
  269.  
  270.     char*& _data;
  271.  
  272.   private:
  273.     String_INOUT_arg();
  274.   };
  275.  
  276.   // omniORB2 private class
  277.   class String_OUT_arg {
  278.   public:
  279.     inline String_OUT_arg(char*& p) : _data(p) { }
  280.     inline String_OUT_arg(String_var& p) : _data(p._data) { p = (char*)0; }
  281.     inline String_OUT_arg(String_member& p) : _data(p._ptr) { p = (char*)0; }
  282.     inline ~String_OUT_arg() {}
  283.  
  284.     char*& _data;
  285.  
  286.   private:
  287.     String_OUT_arg();
  288.   };
  289.  
  290.  
  291. ////////////////////////////////////////////////////////////////////////
  292. //                   Type Any                                         //
  293. ////////////////////////////////////////////////////////////////////////
  294.  
  295.  
  296.   enum TCKind {
  297.     tk_null     = 0,
  298.     tk_void     = 1,
  299.     tk_short    = 2,
  300.     tk_long     = 3,
  301.     tk_ushort    = 4,
  302.     tk_ulong    = 5,
  303.     tk_float    = 6,
  304.     tk_double    = 7,
  305.     tk_boolean    = 8,
  306.     tk_char    = 9,
  307.     tk_octet    = 10,
  308.     tk_any    = 11,
  309.     tk_TypeCode    = 12,
  310.     tk_Principal= 13,
  311.     tk_objref    = 14,
  312.     tk_struct    = 15,
  313.     tk_union    = 16,
  314.     tk_enum    = 17,
  315.     tk_string    = 18,
  316.     tk_sequence    = 19,
  317.     tk_array    = 20,
  318.     tk_alias    = 21,
  319.     tk_except    = 22
  320.   };
  321.   
  322.   class Object;
  323.   typedef Object *Object_ptr;
  324.   typedef Object_ptr ObjectRef;
  325.  
  326.   class TypeCode;
  327.   typedef class TypeCode *TypeCode_ptr;
  328.   typedef TypeCode_ptr TypeCodeRef;
  329.  
  330.   static const TypeCode_ptr _tc_null;
  331.   static const TypeCode_ptr _tc_void;
  332.   static const TypeCode_ptr _tc_short;
  333.   static const TypeCode_ptr _tc_long;
  334.   static const TypeCode_ptr _tc_ushort;
  335.   static const TypeCode_ptr _tc_ulong;
  336.   static const TypeCode_ptr _tc_float;
  337.   static const TypeCode_ptr _tc_double;
  338.   static const TypeCode_ptr _tc_boolean;
  339.   static const TypeCode_ptr _tc_char;
  340.   static const TypeCode_ptr _tc_octet;
  341.   static const TypeCode_ptr _tc_any;
  342.   static const TypeCode_ptr _tc_TypeCode;
  343.   static const TypeCode_ptr _tc_Principal;
  344.   static const TypeCode_ptr _tc_Object;
  345.   static const TypeCode_ptr _tc_string;
  346.  
  347.   static const TypeCode_ptr __nil_TypeCode; 
  348.  
  349.  
  350.   class Any {
  351.   public:
  352.     Any() : pd_data(0) { 
  353.       pd_tc = new TypeCode(tk_null); 
  354.     }
  355.  
  356.     ~Any() { 
  357.       CORBA::release(pd_tc); 
  358.       PR_deleteData();
  359.     }
  360.  
  361.     Any(const Any& a) : pd_data(0) {
  362.       if ((a.pd_tc)->NP_is_nil()) pd_tc = __nil_TypeCode;
  363.       else pd_tc = new TypeCode(*(a.pd_tc));
  364.       pd_mbuf = a.pd_mbuf;
  365.     }
  366.     
  367.     Any(TypeCode_ptr tc, void* value, Boolean release = 0,
  368.     Boolean nocheck = 0);    
  369.  
  370.     
  371.     void operator>>= (NetBufferedStream& s) const;  // Marshalling and 
  372.     void operator<<= (NetBufferedStream& s);  // unmarshalling member functions
  373.  
  374.     void operator>>= (MemBufferedStream& s) const;
  375.     void operator<<= (MemBufferedStream& s);
  376.  
  377.     size_t NP_alignedSize(size_t initialoffset) const;
  378.  
  379.     void NP_memAlignMarshal(MemBufferedStream& m);
  380.  
  381.     inline ULong NP_length() const {
  382.       return (ULong) pd_mbuf.unRead();
  383.     }
  384.  
  385.     void NP_holdData(void* data, void (*del)(void*)) const;
  386.     void NP_getBuffer(MemBufferedStream& mbuf) const;
  387.     void* NP_data() const { return pd_data; }
  388.     
  389.     void NP_replaceData(TypeCode_ptr tcp, const MemBufferedStream& mb);
  390.  
  391.   protected:
  392.     inline void PR_fill(UShort fillerLen,MemBufferedStream& mbuf) const {
  393.       if (fillerLen > 0) {
  394.     Char* filler = new Char[fillerLen];
  395.     try {
  396.       mbuf.put_char_array(filler,fillerLen);
  397.     }
  398.     catch (...) {
  399.       delete[] filler;
  400.       throw;
  401.     }
  402.     delete[] filler;
  403.       }
  404.     }
  405.  
  406.     inline void PR_deleteData() {
  407.       if (pd_data) {
  408.     (*deleteData)(pd_data);    
  409.     pd_data = 0;
  410.       }
  411.     }
  412.  
  413.   public:
  414.  
  415.     inline Any &operator=(const Any& a) {
  416.       if (this != &a) {
  417.     CORBA::release(pd_tc);
  418.     PR_deleteData();
  419.     if ((a.pd_tc)->NP_is_nil()) pd_tc = __nil_TypeCode;
  420.     else pd_tc = new TypeCode(*(a.pd_tc));
  421.     pd_mbuf = a.pd_mbuf;
  422.       }
  423.       return *this;
  424.     }    
  425.  
  426.  
  427.  
  428.     inline void operator<<=(Short s) {
  429.       MemBufferedStream mbuf;
  430.       s >>= mbuf;
  431.       NP_replaceData(_tc_short, mbuf);
  432.     }
  433.  
  434.     inline void operator<<=(UShort u) {
  435.       MemBufferedStream mbuf;
  436.       u >>= mbuf;
  437.       NP_replaceData(_tc_ushort, mbuf);
  438.     }    
  439.  
  440.     inline void operator<<=(Long l) {
  441.       MemBufferedStream mbuf;
  442.       l >>= mbuf;
  443.       NP_replaceData(_tc_long, mbuf);
  444.     }
  445.  
  446.     inline void operator<<=(ULong u) {
  447.       MemBufferedStream mbuf;
  448.       u >>= mbuf;
  449.       NP_replaceData(_tc_ulong, mbuf);
  450.     }
  451.  
  452. #if !defined(NO_FLOAT)
  453.     inline void operator<<=(Float f) {
  454.       MemBufferedStream mbuf;
  455.       f >>= mbuf;
  456.       NP_replaceData(_tc_float, mbuf);     
  457.     }
  458.  
  459.     inline void operator<<=(Double d) {
  460.       MemBufferedStream mbuf;
  461.       d >>= mbuf;
  462.       NP_replaceData(_tc_double, mbuf);
  463.     }
  464. #endif
  465.  
  466.     inline void operator<<=(const Any& a) {
  467.       MemBufferedStream mbuf;
  468.       a >>= mbuf;
  469.       NP_replaceData(_tc_any,mbuf);
  470.     }    
  471.  
  472.     inline void operator<<=(TypeCode_ptr tc) {
  473.       // Copying version
  474.       MemBufferedStream mbuf;
  475.       *tc >>= mbuf;
  476.       NP_replaceData(_tc_TypeCode, mbuf);
  477.     }
  478.  
  479.     inline void operator<<=(TypeCode_ptr* tcp) {
  480.       // Non - copying version
  481.       this->operator<<=(*tcp);
  482.       CORBA::release(*tcp);
  483.     }
  484.     
  485.     inline void operator<<=(const char*& s) {
  486.       MemBufferedStream mbuf;
  487.       ULong _len = strlen(s) + 1;
  488.       _len >>= mbuf;
  489.       mbuf.put_char_array((const CORBA::Char*) s, _len);
  490.       NP_replaceData(_tc_string, mbuf);
  491.     }
  492.     
  493.  
  494.     struct from_boolean {
  495.       from_boolean(Boolean b) : val(b) {}
  496.       Boolean val;
  497.     };
  498.  
  499.     struct from_octet {
  500.       from_octet(Octet b) : val(b) {}
  501.       Octet val;
  502.     };
  503.  
  504.     struct from_char {
  505.       from_char(Char b) : val(b) {}
  506.       Char val;
  507.     };
  508.  
  509.     struct from_string {
  510.       from_string(char* s, ULong b, Boolean nocopy = 0) : val(s), bound(b),
  511.     nc(nocopy) 
  512.     { }
  513.       
  514.       char* val;
  515.       ULong bound;
  516.       Boolean nc;
  517.     };
  518.  
  519.  
  520.     inline void operator<<=(from_boolean f) {
  521.       MemBufferedStream mbuf;
  522.       f.val >>= mbuf;
  523.       NP_replaceData(_tc_boolean, mbuf);
  524.     }
  525.       
  526.     inline void operator<<=(from_char c) {
  527.       MemBufferedStream mbuf;
  528.       c.val >>= mbuf;
  529.       NP_replaceData(_tc_char, mbuf);
  530.     }
  531.     
  532.  
  533.     inline void operator<<=(from_octet o) {
  534.       MemBufferedStream mbuf;
  535.       o.val >>= mbuf;
  536.       NP_replaceData(_tc_octet, mbuf);
  537.     }
  538.     
  539.     void operator<<=(from_string s);
  540.  
  541.  
  542.     inline Boolean operator>>=(Short& s) const {
  543.     if (!pd_tc->NP_expandEqual(_tc_short,1)) return 0;
  544.     else {
  545.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  546.       s <<= tmp_mbuf;
  547.       return 1;
  548.     }
  549.     }
  550.     
  551.     inline Boolean operator>>=(UShort& u) const {
  552.     if (!pd_tc->NP_expandEqual(_tc_ushort,1)) return 0;
  553.     else {
  554.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  555.       u <<= tmp_mbuf;
  556.       return 1;
  557.     }
  558.     }
  559.  
  560.     inline Boolean operator>>=(Long& l) const {
  561.     if (!pd_tc->NP_expandEqual(_tc_long,1)) return 0;
  562.     else {
  563.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  564.       l <<= tmp_mbuf;
  565.       return 1;
  566.     }
  567.     }
  568.  
  569.     inline Boolean operator>>=(ULong& u) const {
  570.     if (!pd_tc->NP_expandEqual(_tc_ulong,1)) return 0;
  571.     else {
  572.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  573.       u <<= tmp_mbuf;
  574.       return 1;
  575.     }
  576.     }
  577.     
  578. #if !defined(NO_FLOAT)
  579.     inline Boolean operator>>=(Float& f) const {
  580.     if (!pd_tc->NP_expandEqual(_tc_float,1)) return 0;
  581.     else {
  582.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  583.       f <<= tmp_mbuf;
  584.       return 1;
  585.     }
  586.       }
  587.  
  588.     inline Boolean operator>>=(Double& d) const {
  589.     if (!pd_tc->NP_expandEqual(_tc_double,1)) return 0;
  590.     else {
  591.       MemBufferedStream tmp_mbuf(pd_mbuf,1);
  592.       d <<= tmp_mbuf;
  593.       return 1;
  594.     }
  595.     }
  596.  
  597. #endif
  598.  
  599.     Boolean operator>>=(Any& a) const; 
  600.  
  601.     Boolean operator>>=(TypeCode_ptr& tc) const; 
  602.  
  603.     Boolean operator>>=(char*& s) const;
  604.  
  605.  
  606.     struct to_boolean {
  607.       to_boolean(Boolean &b) : ref(b) {}
  608.       Boolean &ref;
  609.     };
  610.  
  611.     struct to_char {
  612.       to_char(Char &b) : ref(b) {}
  613.       Char &ref;
  614.     };
  615.  
  616.     struct to_octet {
  617.       to_octet(Octet &b) : ref(b) {}
  618.       Octet &ref;
  619.     };
  620.  
  621.     struct to_string {
  622.       to_string(char*& s, ULong b) : val(s), bound(b) { }
  623.       
  624.       char*& val;
  625.       ULong bound;
  626.     };
  627.       
  628.     struct to_object {
  629.       to_object(Object_ptr& obj) : ref(obj) { }
  630.       Object_ptr& ref;
  631.     };
  632.     
  633.     inline Boolean operator>>=(to_boolean b) const {
  634.       if (!pd_tc->NP_expandEqual(_tc_boolean,1)) return 0;
  635.       else {
  636.     MemBufferedStream tmp_mbuf(pd_mbuf,1);
  637.     b.ref <<= tmp_mbuf;
  638.     return 1;
  639.       }
  640.     }
  641.  
  642.     inline Boolean operator>>=(to_char c) const {
  643.       if (!pd_tc->NP_expandEqual(_tc_char,1)) return 0;
  644.       else {
  645.     MemBufferedStream tmp_mbuf(pd_mbuf,1);
  646.     c.ref <<= tmp_mbuf;
  647.     return 1;
  648.       }
  649.     }
  650.     
  651.     inline Boolean operator>>=(to_octet o) const {
  652.       if (!pd_tc->NP_expandEqual(_tc_octet,1)) return 0;
  653.       else {
  654.     MemBufferedStream tmp_mbuf(pd_mbuf,1);
  655.     o.ref <<= tmp_mbuf;
  656.     return 1;
  657.       }
  658.     }
  659.  
  660.     Boolean operator>>=(to_string s) const;
  661.  
  662.     Boolean operator>>=(to_object o) const;
  663.  
  664.     void replace(TypeCode_ptr TCp, void* value, Boolean release = 0);
  665.  
  666.     inline TypeCode_ptr type() const {
  667.       if (pd_tc->NP_is_nil()) return __nil_TypeCode;
  668.       else return new TypeCode(*pd_tc);
  669.       }
  670.  
  671.     inline const void *value() const {
  672.       return pd_mbuf.data();
  673.     }
  674.  
  675.  
  676.   private:
  677.     void operator<<=(unsigned char);
  678.     Boolean operator>>=(unsigned char&) const;
  679.  
  680.     void* pd_data;
  681.     void (*deleteData)(void*);
  682.  
  683.     TypeCode_ptr pd_tc;
  684.     MemBufferedStream pd_mbuf;
  685.   };
  686.  
  687.   
  688.   class Any_OUT_arg;
  689.  
  690.   class Any_var {
  691.   public:
  692.     inline Any_var() { pd_data = 0; }
  693.     inline Any_var(Any* p) { pd_data = p; }
  694.     inline Any_var(const Any_var &p) {
  695.       if (!p.pd_data) {
  696.     pd_data = 0;
  697.     return;
  698.       }
  699.       else {
  700.     pd_data = new Any;
  701.     if (!pd_data) {
  702.       _CORBA_new_operator_return_null();
  703.       // never reach here
  704.     }
  705.     *pd_data = *p.pd_data;
  706.       }
  707.     }
  708.  
  709.     inline ~Any_var() {  if (pd_data) delete pd_data; }
  710.     inline Any_var &operator= (Any* p) {  
  711.       if (pd_data) delete pd_data;
  712.       pd_data = p;
  713.       return *this;
  714.     }
  715.  
  716.     inline Any_var &operator= (const Any_var &p) {
  717.         if (p.pd_data) {
  718.       if (!pd_data) {
  719.         pd_data = new Any;
  720.         if (!pd_data) {
  721.           _CORBA_new_operator_return_null();
  722.           // never reach here
  723.         }
  724.       }
  725.       *pd_data = *p.pd_data;
  726.     }
  727.     else {
  728.       if (pd_data) delete pd_data;
  729.       pd_data = 0;
  730.     }
  731.     return *this;
  732.     }
  733.  
  734.     inline Any* operator->() const { return (Any*)pd_data; }
  735.     
  736. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  737.     inline operator Any& () const { return (Any&) *pd_data; }
  738. #else
  739.     inline operator const Any& () const { return *pd_data; }
  740.     inline operator Any& () { return *pd_data; }
  741. #endif
  742.  
  743.  
  744.     // Any member-function insertion operators:
  745.  
  746.     inline void operator<<=(Short s) {
  747.       *pd_data <<= s;
  748.     }
  749.  
  750.     inline void operator<<=(UShort u) {
  751.       *pd_data <<= u;
  752.     }    
  753.  
  754.     inline void operator<<=(Long l) {
  755.       *pd_data <<= l;
  756.    }
  757.  
  758.     inline void operator<<=(ULong u) {
  759.       *pd_data <<= u;
  760.     }
  761.  
  762. #if !defined(NO_FLOAT)
  763.     inline void operator<<=(Float f) {
  764.       *pd_data <<= f;
  765.     }
  766.  
  767.     inline void operator<<=(Double d) {
  768.       *pd_data <<= d;
  769.     }
  770. #endif
  771.  
  772.     inline void operator<<=(const Any& a) {
  773.       *pd_data <<= a;
  774.     }    
  775.  
  776.     inline void operator<<=(TypeCode_ptr tc) {
  777.       *pd_data <<= tc;
  778.     }
  779.  
  780.     inline void operator<<=(TypeCode_ptr* tcp) {
  781.       *pd_data <<= tcp;
  782.     }
  783.     
  784.     inline void operator<<=(const char*& s) {
  785.       *pd_data <<= s;
  786.     }
  787.     
  788.     inline void operator<<=(Any::from_boolean f) {
  789.       *pd_data <<= f;
  790.     }
  791.       
  792.     inline void operator<<=(Any::from_char c) {
  793.       *pd_data <<= c;
  794.     }
  795.     
  796.  
  797.     inline void operator<<=(Any::from_octet o) {
  798.       *pd_data <<= o;
  799.     }
  800.     
  801.     inline void operator<<=(Any::from_string s){
  802.       *pd_data <<= s;
  803.     }
  804.  
  805.  
  806.     // Any member-function extraction operators:
  807.  
  808.     inline Boolean operator>>=(Short& s) const {
  809.       return (*pd_data >>= s);
  810.     }
  811.     
  812.     inline Boolean operator>>=(UShort& u) const {
  813.       return (*pd_data >>= u);
  814.     }
  815.  
  816.     inline Boolean operator>>=(Long& l) const {
  817.       return (*pd_data >>= l);
  818.     }
  819.  
  820.     inline Boolean operator>>=(ULong& u) const {
  821.       return (*pd_data >>= u);
  822.     }
  823.     
  824. #if !defined(NO_FLOAT)
  825.     inline Boolean operator>>=(Float& f) const {
  826.       return (*pd_data >>= f);
  827.       }
  828.  
  829.     inline Boolean operator>>=(Double& d) const {
  830.       return (*pd_data >>= d);
  831.     }
  832.  
  833. #endif
  834.  
  835.     inline Boolean operator>>=(Any& a) const {
  836.       return (*pd_data >>= a);
  837.     }
  838.  
  839.     inline Boolean operator>>=(TypeCode_ptr& tc) const {
  840.       return (*pd_data >>= tc);
  841.     }
  842.  
  843.     inline Boolean operator>>=(char*& s) const {
  844.       return (*pd_data >>= s);
  845.     }
  846.  
  847.     inline Boolean operator>>=(Any::to_boolean b) const {
  848.       return (*pd_data >>= b);
  849.     }
  850.  
  851.     inline Boolean operator>>=(Any::to_char c) const {
  852.       return (*pd_data >>= c);
  853.     }
  854.     
  855.     inline Boolean operator>>=(Any::to_octet o) const {
  856.       return (*pd_data >>= o);
  857.     }
  858.  
  859.     inline Boolean operator>>=(Any::to_string s) const {
  860.       return (*pd_data >>= s);
  861.     }
  862.  
  863.     inline Boolean operator>>=(Any::to_object o) const {
  864.       return (*pd_data >>= o);
  865.     }
  866.  
  867.  
  868.     friend class Any_OUT_arg;
  869.  
  870.   private:
  871.     Any* pd_data;
  872.   };
  873.  
  874.  
  875.   class Any_OUT_arg {
  876.   public:
  877.     inline Any_OUT_arg(Any*& p) : _data(p) {}
  878.     inline Any_OUT_arg(Any_var& p) : _data(p.pd_data) {
  879.       p = (Any*)0;
  880.     }
  881.     Any*& _data;
  882.   private:
  883.     Any_OUT_arg();
  884.   };
  885.  
  886.  
  887. ////////////////////////////////////////////////////////////////////////
  888. //                   PIDL Exception                                   //
  889. ////////////////////////////////////////////////////////////////////////
  890.  
  891.   class Exception {
  892.   public:
  893.     virtual ~Exception() {}
  894.   protected:
  895.     Exception() {}
  896.   };
  897.  
  898.   enum CompletionStatus { COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE };
  899.   class SystemException : public Exception {
  900.   public:
  901.     SystemException() {
  902.       pd_minor = 0;
  903.       pd_status = COMPLETED_NO;
  904.     }
  905.  
  906.     SystemException(const SystemException &e) {
  907.       pd_minor = e.pd_minor;
  908.       pd_status = e.pd_status;
  909.     }
  910.  
  911.     SystemException(ULong minor, CompletionStatus status) {
  912.       pd_minor = minor;
  913.       pd_status = status;
  914.       return;
  915.     }
  916.  
  917.     virtual ~SystemException() {}
  918.  
  919.     SystemException &operator=(const SystemException &e) {
  920.       pd_minor = e.pd_minor;
  921.       pd_status = e.pd_status;
  922.       return *this;
  923.     }
  924.  
  925. #ifdef minor
  926.     // Digital Unix 3.2, and may be others as well, defines minor() as
  927.     // a macro in its sys/types.h. Get rid of it!
  928. #undef minor
  929. #endif
  930.  
  931.     ULong minor() const { return pd_minor; }
  932.  
  933.     void minor(ULong m) { pd_minor = m; return; }
  934.  
  935.     CompletionStatus completed() const { return pd_status; }
  936.  
  937.     void completed(CompletionStatus s) { pd_status = s; return; }
  938.  
  939.     virtual const char * NP_RepositoryId() const { return ""; }
  940.  
  941.   protected:
  942.     ULong             pd_minor;
  943.     CompletionStatus  pd_status;
  944.   };
  945.  
  946. #define  STD_EXCEPTION(name) \
  947.   class name : public SystemException { \
  948.   public: \
  949.        name (ULong minor = 0, CompletionStatus completed = COMPLETED_NO \
  950.        ) : SystemException (minor,completed) {} \
  951.        virtual const char * NP_RepositoryId() const; \
  952.   }
  953.  
  954.   STD_EXCEPTION (UNKNOWN);
  955.   STD_EXCEPTION (BAD_PARAM);
  956.   STD_EXCEPTION (NO_MEMORY);
  957.   STD_EXCEPTION (IMP_LIMIT);
  958.   STD_EXCEPTION (COMM_FAILURE);
  959.   STD_EXCEPTION (INV_OBJREF);
  960.   STD_EXCEPTION (OBJECT_NOT_EXIST);
  961.   STD_EXCEPTION (NO_PERMISSION);
  962.   STD_EXCEPTION (INTERNAL);
  963.   STD_EXCEPTION (MARSHAL);
  964.   STD_EXCEPTION (INITIALIZE);
  965.   STD_EXCEPTION (NO_IMPLEMENT);
  966.   STD_EXCEPTION (BAD_TYPECODE);
  967.   STD_EXCEPTION (BAD_OPERATION);
  968.   STD_EXCEPTION (NO_RESOURCES);
  969.   STD_EXCEPTION (NO_RESPONSE);
  970.   STD_EXCEPTION (PERSIST_STORE);
  971.   STD_EXCEPTION (BAD_INV_ORDER);
  972.   STD_EXCEPTION (TRANSIENT);
  973.   STD_EXCEPTION (FREE_MEM);
  974.   STD_EXCEPTION (INV_IDENT);
  975.   STD_EXCEPTION (INV_FLAG);
  976.   STD_EXCEPTION (INTF_REPOS);
  977.   STD_EXCEPTION (BAD_CONTEXT);
  978.   STD_EXCEPTION (OBJ_ADAPTER);
  979.   STD_EXCEPTION (DATA_CONVERSION);
  980.   STD_EXCEPTION (TRANSACTION_REQUIRED);
  981.   STD_EXCEPTION (TRANSACTION_ROLLEDBACK);
  982.   STD_EXCEPTION (INVALID_TRANSACTION);
  983.   STD_EXCEPTION (WRONG_TRANSACTION);
  984.  
  985. #undef STD_EXCEPTION
  986.  
  987.   class UserException : public Exception {
  988.   public:
  989.     UserException() {}
  990.     virtual ~UserException() {}
  991.     UserException(const UserException &e) {}
  992.     UserException &operator= (const UserException &e) { return *this; }
  993.   };
  994.  
  995.   class UnknownUserException : public UserException {
  996.   public:
  997.     Any &exception();
  998.   private:
  999.     UnknownUserException(); // not implemented yet
  1000.   };
  1001.  
  1002.  
  1003. ////////////////////////////////////////////////////////////////////////
  1004. //                   PIDL Environment                                 //
  1005. ////////////////////////////////////////////////////////////////////////
  1006.  
  1007.   class Environment;
  1008.   typedef Environment *Environment_ptr;
  1009.   typedef Environment_ptr EnvironmentRef;
  1010.  
  1011.   class Environment {
  1012.   public:
  1013.     void exception(Exception *);
  1014.     Exception *exception() const;
  1015.     void clear();
  1016.  
  1017.     static Environment_ptr _duplicate();
  1018.     static Environment_ptr _nil();
  1019.   private:
  1020.     Environment(); // Not implemented yet
  1021.   };
  1022.  
  1023. ////////////////////////////////////////////////////////////////////////
  1024. //                   PIDL NamedValue                                  //
  1025. ////////////////////////////////////////////////////////////////////////
  1026.  
  1027.   enum Flags { ARG_IN, ARG_OUT, ARG_INOUT };
  1028.  
  1029.   class NamedValue;
  1030.   typedef NamedValue* NamedValue_ptr;
  1031.   typedef NamedValue_ptr NamedValueRef;
  1032.  
  1033.   class NamedValue {
  1034.   public:
  1035.     const char *name() const;
  1036.     Any *value() const;
  1037.     Flags flags() const;
  1038.  
  1039.     static NamedValue_ptr _duplicate();
  1040.     static NamedValue_ptr _nil();
  1041.   private:
  1042.     NamedValue(); // Not implemented yet
  1043.   };
  1044.  
  1045.   class NVList;
  1046.   typedef NVList *NVList_ptr;
  1047.   typedef NVList_ptr NVListRef;
  1048.  
  1049.  
  1050.   class NVList {
  1051.   public:
  1052.     NamedValue_ptr add(Flags);
  1053.     NamedValue_ptr add_item(const char*, Flags);
  1054.     NamedValue_ptr add_value(const char*, const Any&, Flags);
  1055.     NamedValue_ptr add_item_consume(char*,Flags);
  1056.     NamedValue_ptr add_value_consume(char*, Any *, Flags);
  1057.  
  1058.     ULong count() const;
  1059.     NamedValue_ptr item(ULong);
  1060.     Status remove (ULong);
  1061.     
  1062.     static NVList_ptr _duplicate();
  1063.     static NVList_ptr _nil();
  1064.   private:
  1065.     NVList(); // Not implemented yet
  1066.   };
  1067.  
  1068. ////////////////////////////////////////////////////////////////////////
  1069. //                   PIDL Context                                     //
  1070. ////////////////////////////////////////////////////////////////////////
  1071.  
  1072.   class Context;
  1073.   typedef Context *Context_ptr;
  1074.   typedef Context_ptr ContextRef;
  1075.  
  1076.   class Context {
  1077.   public:
  1078.     const char *context_name() const;
  1079.     Context_ptr parent() const;
  1080.     Status create_child(const char *, Context_ptr&);
  1081.     Status set_one_value(const char *,const Any&);
  1082.     Status delete_values(const char *);
  1083.     Status get_values(const char*, Flags, const char*, NVList_ptr &);
  1084.     
  1085.     static Context_ptr _duplicate();
  1086.     static Context_ptr _nil();
  1087.   private:
  1088.     Context(); // Not implemented yet
  1089.   };
  1090.  
  1091. ////////////////////////////////////////////////////////////////////////
  1092. //                   PIDL ContextList                                 //
  1093. ////////////////////////////////////////////////////////////////////////
  1094.  
  1095.   class ContextList;
  1096.   typedef ContextList* ContextList_ptr;
  1097.   typedef ContextList_ptr ContextListRef;
  1098.  
  1099.   class ContextList {
  1100.   public:
  1101.     ULong count();
  1102.     void add(const char* ctxt);
  1103.     void add_consume(char* ctxt);
  1104.     const char* item(ULong index);
  1105.     Status remove(ULong index);
  1106.   private:
  1107.     ContextList(); // Not implemented yet
  1108.   };
  1109.  
  1110. ////////////////////////////////////////////////////////////////////////
  1111. //                   PIDL Principal                                   //
  1112. ////////////////////////////////////////////////////////////////////////
  1113.  
  1114.   class Principal;
  1115.   typedef Principal* Principal_ptr;
  1116.   typedef Principal_ptr PrincipalRef;
  1117.  
  1118.   typedef _CORBA_Unbounded_Sequence_Octet PrincipalID;
  1119.  
  1120.   class Principal {
  1121.   public:
  1122.     static Principal_ptr _duplicate();
  1123.     static Principal_ptr _nil();
  1124.   private:
  1125.     Principal(); // Not implemented yet
  1126.   };
  1127.  
  1128. ////////////////////////////////////////////////////////////////////////
  1129. //                   PIDL ExceptionList                               //
  1130. ////////////////////////////////////////////////////////////////////////
  1131.  
  1132.   class ExceptionList {
  1133.   public:
  1134.     ULong count();
  1135.     void add(TypeCode_ptr tc);
  1136.     void add_consume(TypeCode_ptr tc);
  1137.     TypeCode_ptr item(ULong index);
  1138.     Status remove(ULong index);
  1139.   private:
  1140.     ExceptionList(); // Not implemented yet
  1141.   };
  1142.   typedef ExceptionList* ExceptionList_ptr;
  1143.   typedef ExceptionList_ptr ExceptionListRef;
  1144.  
  1145.  
  1146.   //////////////////////////////////////////////////////////////////////
  1147.   //    Interface repository types                                    //
  1148.   //////////////////////////////////////////////////////////////////////
  1149.   typedef char *RepositoryId;
  1150.  
  1151.   class InterfaceDef {
  1152.   public:
  1153.     _CORBA_Unbounded_Sequence_Octet _data;
  1154.   private:
  1155.     InterfaceDef();
  1156.     // Not implemented yet
  1157.   };
  1158.   typedef class InterfaceDef *InterfaceDef_ptr;
  1159.   typedef InterfaceDef_ptr InterfaceDefRef;
  1160.  
  1161.   enum DefinitionKind { 
  1162.     dk_none, dk_all, dk_Attribute, dk_Constant, 
  1163.     dk_Exception, dk_Interface, dk_Module, dk_Operation, 
  1164.     dk_Typedef, dk_Alias, dk_Struct, dk_Union, dk_Enum, 
  1165.     dk_Primitive, dk_String, dk_Sequence, dk_Array, dk_Repository 
  1166.   };
  1167.  
  1168.   friend inline void operator>>= (DefinitionKind _e,NetBufferedStream &s) {
  1169.     ::operator>>=((CORBA::ULong)_e,s);
  1170.   }
  1171.  
  1172.   friend inline void operator<<= (DefinitionKind &_e,NetBufferedStream &s) {
  1173.     CORBA::ULong __e;
  1174.     __e <<= s;
  1175.     switch (__e) {
  1176.       case dk_none:
  1177.       case dk_all:
  1178.       case dk_Attribute:
  1179.       case dk_Constant:
  1180.       case dk_Exception:
  1181.       case dk_Interface:
  1182.       case dk_Module:
  1183.       case dk_Operation:
  1184.       case dk_Typedef:
  1185.       case dk_Alias:
  1186.       case dk_Struct:
  1187.       case dk_Union:
  1188.       case dk_Enum:
  1189.       case dk_Primitive:
  1190.       case dk_String:
  1191.       case dk_Sequence:
  1192.       case dk_Array:
  1193.       case dk_Repository:
  1194.         _e = (DefinitionKind) __e;
  1195.         break;
  1196.       default:
  1197.         _CORBA_marshal_error();
  1198.     }
  1199.   }
  1200.  
  1201.   friend inline void operator>>= (DefinitionKind _e,MemBufferedStream &s) {
  1202.     ::operator>>=((CORBA::ULong)_e,s);
  1203.   }
  1204.  
  1205.   friend inline void operator<<= (DefinitionKind &_e,MemBufferedStream &s) {
  1206.     CORBA::ULong __e;
  1207.     __e <<= s;
  1208.     switch (__e) {
  1209.       case dk_none:
  1210.       case dk_all:
  1211.       case dk_Attribute:
  1212.       case dk_Constant:
  1213.       case dk_Exception:
  1214.       case dk_Interface:
  1215.       case dk_Module:
  1216.       case dk_Operation:
  1217.       case dk_Typedef:
  1218.       case dk_Alias:
  1219.       case dk_Struct:
  1220.       case dk_Union:
  1221.       case dk_Enum:
  1222.       case dk_Primitive:
  1223.       case dk_String:
  1224.       case dk_Sequence:
  1225.       case dk_Array:
  1226.       case dk_Repository:
  1227.         _e = (DefinitionKind) __e;
  1228.         break;
  1229.       default:
  1230.         _CORBA_marshal_error();
  1231.     }
  1232.   }
  1233.  
  1234.   
  1235.   class IRObject;
  1236.   typedef IRObject *IRObject_ptr;
  1237.   typedef IRObject_ptr IRObjectRef;
  1238.  
  1239.   class IRObject {
  1240.   public:
  1241.  
  1242.     // Not implemented yet - used by IR
  1243.  
  1244.     virtual ~IRObject() {}
  1245.  
  1246.     virtual DefinitionKind def_kind() {
  1247.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1248.     return dk_none;
  1249.     }
  1250.  
  1251.     virtual void destroy() {
  1252.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1253.     }
  1254.  
  1255.     static IRObject_ptr _duplicate(IRObject_ptr obj) {
  1256.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1257.     return 0;
  1258.     }
  1259.       
  1260.     static IRObject_ptr _narrow(Object_ptr obj) {
  1261.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1262.     return 0;
  1263.     }
  1264.  
  1265.     static IRObject_ptr _nil() {
  1266.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1267.     return 0;
  1268.     }
  1269.  
  1270.   protected:
  1271.     IRObject() { }
  1272.  
  1273.   private:    
  1274.     IRObject(const IRObject&);
  1275.     IRObject &operator=(const IRObject&);
  1276.   };
  1277.   
  1278.   class IDLType;
  1279.   typedef IDLType* IDLType_ptr;
  1280.   typedef IDLType_ptr IDLTypeRef;
  1281.  
  1282.   class TypeCode_var;
  1283.  
  1284.   class TypeCode_member {
  1285.   public:
  1286.     TypeCode_member() { _ptr = __nil_TypeCode; }
  1287.  
  1288.     inline TypeCode_member(TypeCode_ptr p) { _ptr = p; }
  1289.  
  1290.     inline TypeCode_member(const TypeCode_member& p) {
  1291.       if ((p._ptr)->NP_is_nil()) _ptr = __nil_TypeCode; 
  1292.       else _ptr = new TypeCode(*(p._ptr));
  1293.       }
  1294.  
  1295.     ~TypeCode_member() { CORBA::release(_ptr); }
  1296.  
  1297.     
  1298.     inline TypeCode_member& operator=(TypeCode_ptr p) {
  1299.     CORBA::release(_ptr);
  1300.     _ptr = p;
  1301.     return *this;
  1302.     }
  1303.  
  1304.     
  1305.     inline TypeCode_member& operator=(const TypeCode_member& p) {
  1306.       if (this != &p) {
  1307.     CORBA::release(_ptr);
  1308.       if ((p._ptr)->NP_is_nil()) _ptr = __nil_TypeCode; 
  1309.       else _ptr = new TypeCode(*(p._ptr));
  1310.       }
  1311.       return *this;
  1312.     }
  1313.  
  1314.     inline TypeCode_member& operator=(const TypeCode_var& p) {
  1315.       CORBA::release(_ptr);
  1316.       if ((p.pd_TC)->NP_is_nil()) _ptr = __nil_TypeCode;
  1317.       else _ptr = new TypeCode(*(p.pd_TC));
  1318.       return *this;
  1319.     }
  1320.  
  1321.  
  1322.     inline void operator>>=(NetBufferedStream& s) const { *_ptr >>= s; }
  1323.     inline void operator<<=(NetBufferedStream& s) {
  1324.     TypeCode_ptr _result = new TypeCode(tk_null);
  1325.     *_result <<= s;
  1326.     CORBA::release(_ptr);
  1327.     _ptr = _result;
  1328.       }
  1329.  
  1330.     inline void operator>>=(MemBufferedStream& s) const { *_ptr >>= s; }
  1331.     inline void operator<<=(MemBufferedStream& s) {
  1332.     TypeCode_ptr _result = new TypeCode(tk_null);
  1333.     *_result <<= s;
  1334.     CORBA::release(_ptr);
  1335.     _ptr = _result;
  1336.     }
  1337.       
  1338.     inline size_t NP_alignedSize(size_t initialoffset) const {
  1339.       return _ptr->NP_alignedSize(initialoffset);
  1340.     }
  1341.  
  1342.     
  1343.     inline TypeCode_ptr operator->() const { return (TypeCode_ptr) _ptr; }
  1344.     inline operator TypeCode_ptr() const { return _ptr; }
  1345.  
  1346.  
  1347.     TypeCode_ptr _ptr;
  1348.   };
  1349.  
  1350.  
  1351.  
  1352.   struct StructMember {    
  1353.     String_member name;
  1354.     TypeCode_member type;
  1355.     IDLType_ptr type_def;
  1356.  
  1357.     size_t NP_alignedSize(size_t initialoffset) const;
  1358.     void operator>>= (NetBufferedStream &) const;
  1359.     void operator<<= (NetBufferedStream &);
  1360.     void operator>>= (MemBufferedStream &) const;
  1361.     void operator<<= (MemBufferedStream &);
  1362.   };
  1363.  
  1364.   typedef _CORBA_ConstrType_Variable_Var<StructMember> StructMember_var;
  1365.   typedef _CORBA_Unbounded_Sequence<StructMember> StructMemberSeq;
  1366.  
  1367.  
  1368.   struct UnionMember {
  1369.     String_member name;
  1370.     Any label;
  1371.     TypeCode_member type;
  1372.     IDLType_ptr type_def;
  1373.  
  1374.     size_t NP_alignedSize(size_t initialoffset) const;
  1375.     void operator>>= (NetBufferedStream &) const;
  1376.     void operator<<= (NetBufferedStream &);
  1377.     void operator>>= (MemBufferedStream &) const;
  1378.     void operator<<= (MemBufferedStream &);
  1379.   };
  1380.  
  1381.   typedef _CORBA_ConstrType_Variable_Var<UnionMember> UnionMember_var;
  1382.   typedef _CORBA_Unbounded_Sequence<UnionMember> UnionMemberSeq;
  1383.  
  1384.  
  1385.   typedef _CORBA_Unbounded_Sequence<String_member> EnumMemberSeq;
  1386.  
  1387.  
  1388. ////////////////////////////////////////////////////////////////////////
  1389. //                   PIDL Object                                      //
  1390. ////////////////////////////////////////////////////////////////////////
  1391.  
  1392.   class Request;
  1393.   typedef Request *Request_ptr;
  1394.   typedef Request_ptr RequestRef;
  1395.  
  1396.   typedef _CORBA_Unbounded_Sequence_Octet ReferenceData;
  1397.  
  1398.   class ImplementationDef;
  1399.   typedef ImplementationDef* ImplementationDef_ptr;
  1400.   typedef ImplementationDef_ptr ImplementationDefRef;
  1401.  
  1402.   class ImplementationDef {
  1403.   public:
  1404.     _CORBA_Unbounded_Sequence_Octet _data;
  1405.   private:
  1406.     ImplementationDef(); // Not implemented yet;
  1407.   };
  1408.  
  1409.   class Object_Helper {
  1410.   public:
  1411.     // omniORB2 specifics
  1412.     static Object_ptr _nil();
  1413.     static _CORBA_Boolean is_nil(Object_ptr obj);
  1414.     static void release(Object_ptr obj);
  1415.     static void duplicate(Object_ptr obj);
  1416.     static size_t NP_alignedSize(Object_ptr obj,size_t initialoffset);
  1417.     static void marshalObjRef(Object_ptr obj,NetBufferedStream &s);
  1418.     static Object_ptr unmarshalObjRef(NetBufferedStream &s);
  1419.     static void marshalObjRef(Object_ptr obj,MemBufferedStream &s);
  1420.     static Object_ptr unmarshalObjRef(MemBufferedStream &s);
  1421.   };
  1422.  
  1423.   class Object {
  1424.   public:
  1425.  
  1426. #if defined(SUPPORT_DII)
  1427.  
  1428.      Status _create_request(Context_ptr ctx,
  1429.                const char *operation,
  1430.                NVList_ptr arg_list,
  1431.                NamedValue_ptr result,
  1432.                Request_ptr &request,
  1433.                Flags req_flags) ;
  1434.  
  1435.      Status _create_request(Context_ptr ctx,
  1436.                const char *operation,
  1437.                NVList_ptr arg_list,
  1438.                NamedValue_ptr result,
  1439.                ExceptionList_ptr exceptions,
  1440.                ContextList_ptr ctxlist,
  1441.                Request_ptr &request,
  1442.                Flags req_flags) ;
  1443.  
  1444.      Request_ptr _request(const char* operation) ;
  1445.  
  1446. #endif // SUPPORT_DII
  1447.  
  1448.      ImplementationDef_ptr _get_implementation() ;
  1449.      InterfaceDef_ptr      _get_interface() ;
  1450.     _CORBA_Boolean _is_a(const char *repoId);
  1451.     _CORBA_Boolean _non_existent();
  1452.     _CORBA_Boolean _is_equivalent(Object_ptr other_object);
  1453.     _CORBA_ULong   _hash(_CORBA_ULong maximum);
  1454.  
  1455.     static Object_ptr _duplicate(Object_ptr obj);
  1456.     static Object_ptr _nil();
  1457.  
  1458.     Object();
  1459.     virtual ~Object() {}
  1460.  
  1461.     // omniORB2 specifics
  1462.     void NP_release();
  1463.     _CORBA_Boolean NP_is_nil() const;
  1464.     void PR_setobj(omniObject *obj);
  1465.     omniObject *PR_getobj();
  1466.     static size_t NP_alignedSize(Object_ptr obj,size_t initialoffset);
  1467.     static void marshalObjRef(Object_ptr obj,NetBufferedStream &s);
  1468.     static Object_ptr unmarshalObjRef(NetBufferedStream &s);
  1469.     static void marshalObjRef(Object_ptr obj,MemBufferedStream &s);
  1470.     static Object_ptr unmarshalObjRef(MemBufferedStream &s);
  1471.     static Object CORBA_Object_nil;
  1472.     static const _CORBA_Char* repositoryID;
  1473.  
  1474.   private:
  1475.     omniObject *pd_obj;
  1476.   };
  1477.  
  1478.  
  1479.   class _nil_IDLType;
  1480.  
  1481.   static IDLType_ptr __nil_IDLType;
  1482.  
  1483.   class IDLType : public virtual IRObject, public virtual omniObject,
  1484.                   public virtual Object {
  1485.   public:
  1486.  
  1487.     // Not implemented yet - used by IR
  1488.  
  1489.     virtual ~IDLType() {}
  1490.  
  1491.     virtual TypeCode_ptr type() {
  1492.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1493.     return 0;
  1494.     }
  1495.  
  1496.     static IDLType_ptr _duplicate(IDLType_ptr obj) {
  1497.       if (CORBA::is_nil(obj))
  1498.     return IDLType::_nil();
  1499.       else {
  1500.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1501.     return 0;
  1502.       }
  1503.     }
  1504.     
  1505.     static IDLType_ptr _narrow(Object_ptr obj) {
  1506.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1507.     return 0;
  1508.     }
  1509.     
  1510.     static inline IDLType_ptr _nil()  {
  1511.       if (!CORBA::__nil_IDLType) {
  1512.     CORBA::__nil_IDLType = new _nil_IDLType;
  1513.       }
  1514.       return __nil_IDLType;
  1515.     }
  1516.  
  1517.     static inline size_t NP_alignedSize(IDLType_ptr obj,size_t initialoffset) {
  1518.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1519.     return 0;      
  1520.     }
  1521.  
  1522.     static inline void marshalObjRef(IDLType_ptr obj,NetBufferedStream &s) {
  1523.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1524.     }
  1525.  
  1526.     static inline IDLType_ptr unmarshalObjRef(NetBufferedStream &s) {
  1527.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1528.     return 0;
  1529.     }
  1530.  
  1531.     static inline void marshalObjRef(IDLType_ptr obj,MemBufferedStream &s) {
  1532.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1533.     }
  1534.  
  1535.     static inline IDLType_ptr unmarshalObjRef(MemBufferedStream &s) {
  1536.     throw CORBA::NO_IMPLEMENT(0,CORBA::COMPLETED_NO);
  1537.     return 0;
  1538.     }
  1539.  
  1540.   protected:
  1541.     
  1542.     IDLType() {}
  1543.   };
  1544.  
  1545.   class _nil_IDLType : public virtual IDLType {
  1546.   public:
  1547.     _nil_IDLType() : omniObject(omniObject::nilObjectManager()) 
  1548.       { this->PR_setobj(0); }
  1549.     virtual ~_nil_IDLType() {}
  1550.     
  1551.     TypeCode_ptr type (){
  1552.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1553.       // never reach here! Dummy return to keep some compilers happy.
  1554.       TypeCode_ptr _result= 0;
  1555.       return _result;
  1556.     }
  1557.   };
  1558.  
  1559.  
  1560. ////////////////////////////////////////////////////////////////////////
  1561. //                   PIDL TypeCode                                    //
  1562. ////////////////////////////////////////////////////////////////////////
  1563.  
  1564.   struct PR_structMember {
  1565.     // Private omniORB type
  1566.     const char* name;
  1567.     TypeCode_ptr type;
  1568.   };
  1569.  
  1570.   struct PR_unionMember {
  1571.     // Private omniORB type
  1572.     const char* name;
  1573.     TypeCode_ptr type;
  1574.     _CORBA_ULong label;
  1575.   };
  1576.   
  1577.   
  1578.   class TypeCode {
  1579.   public:
  1580.  
  1581.     TypeCode(TCKind t, ULong maxLen = 0); // Predefined-type and string
  1582.  
  1583.     TypeCode(const char* repoId, const char* name);
  1584.                             // Object Reference
  1585.  
  1586.     TypeCode(const char* repoId, const char* name, 
  1587.          const TypeCode& contentTC);
  1588.                             // Typedef
  1589.     TypeCode(TCKind t, ULong length, const TypeCode& contentTC); 
  1590.                                                   // Sequence, array
  1591.     TypeCode(TCKind t, const char* repoId, const char* name, 
  1592.          const StructMemberSeq& members);          
  1593.                                                  // Struct, Exception
  1594.     TypeCode(const char* repoId, const char* name, 
  1595.           const EnumMemberSeq& members);            // Enum
  1596.  
  1597.     TypeCode(const char* repoId, const char* name, 
  1598.          const TypeCode_ptr discriminatorTC, 
  1599.          const UnionMemberSeq& members);           // Union
  1600.  
  1601.     // TypeCode interface for stubs:
  1602.  
  1603.     TypeCode(TCKind t, const char* repoId, const char* name, 
  1604.          PR_structMember* members, ULong num_mems);          
  1605.                                                  // Struct, Exception
  1606.     TypeCode(const char* repoId, const char* name, 
  1607.           char** members, ULong num_mems);            // Enum
  1608.  
  1609.     TypeCode(const char* repoId, const char* name, 
  1610.          const TypeCode& discriminatorTC, 
  1611.          PR_unionMember* members, ULong num_mems, Long def = -1);     
  1612.                                                           // Union
  1613.  
  1614.  
  1615.     virtual ~TypeCode() { }                          // Destructor
  1616.  
  1617.     TypeCode(const TypeCode& tc);            // Copy Constructor
  1618.     TypeCode& operator=(const TypeCode& tc); 
  1619.  
  1620.     
  1621.     void operator>>= (NetBufferedStream& s) const;  // Marshalling and 
  1622.     void operator<<= (NetBufferedStream& s);  // unmarshalling member functions
  1623.  
  1624.     void operator>>= (MemBufferedStream& s) const;
  1625.     void operator<<= (MemBufferedStream& s);
  1626.  
  1627.     size_t NP_alignedSize(size_t initialoffset) const;
  1628.     Boolean NP_expandEqual(TypeCode_ptr, Boolean) const;
  1629.     void NP_fillInit(MemBufferedStream& mbuf) const;
  1630.     virtual Boolean NP_is_nil() const;
  1631.     TypeCode_ptr NP_aliasExpand() const;
  1632.     TypeCode_ptr NP_completeExpand() const;
  1633.  
  1634.  
  1635.     // OMG Interface:
  1636.  
  1637.     class Bounds : public UserException {
  1638.     public: 
  1639.       Bounds () : UserException () {}
  1640.       ~Bounds() { }
  1641.     };
  1642.  
  1643.     class BadKind : public UserException {
  1644.     public:
  1645.       BadKind () : UserException () {}
  1646.       ~BadKind () { }
  1647.     };
  1648.  
  1649.     
  1650.  
  1651.     inline TCKind kind() const { return pd_tck; }
  1652.     inline Boolean equal(TypeCode_ptr TCp) const { 
  1653.       return NP_expandEqual(TCp,0); }
  1654.  
  1655.     virtual const char* id() const;
  1656.     virtual const char* name() const;
  1657.     
  1658.     virtual ULong member_count() const;
  1659.     virtual const char* member_name(ULong index) const;
  1660.  
  1661.     virtual TypeCode_ptr member_type(ULong index) const;
  1662.  
  1663.     virtual Any *member_label(ULong index) const;
  1664.     virtual TypeCode_ptr discriminator_type() const;
  1665.     virtual Long default_index() const;
  1666.  
  1667.     virtual ULong length() const;
  1668.  
  1669.     virtual TypeCode_ptr content_type() const;
  1670.  
  1671.     virtual Long param_count() const;
  1672.     virtual Any *parameter(Long) const;
  1673.  
  1674.     static TypeCode_ptr _duplicate(TypeCode_ptr t);
  1675.     static TypeCode_ptr _nil();
  1676.  
  1677.     friend class tcParseEngine;
  1678.     friend class Any;
  1679.  
  1680.   private:
  1681.  
  1682.     TCKind pd_tck;
  1683.     ULong  pd_maxLen;
  1684.     MemBufferedStream pd_param;
  1685.  
  1686.     Boolean PR_equal(TypeCode_ptr, Boolean expand) const;
  1687.  
  1688.     TypeCode();
  1689.   };
  1690.  
  1691.  
  1692.  
  1693.   class _nil_TypeCode : public virtual TypeCode {
  1694.   public:
  1695.     _nil_TypeCode() : TypeCode(tk_null) {  }
  1696.     virtual ~_nil_TypeCode() {}
  1697.  
  1698.     virtual Boolean NP_is_nil() const;
  1699.  
  1700.     // OMG interface:
  1701.  
  1702.     const char* id () const {
  1703.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1704.       // never reach here! Dummy return to keep some compilers happy.
  1705.       char * _result= 0;
  1706.       return _result;
  1707.     }
  1708.  
  1709.     const char* name () const {
  1710.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1711.       // never reach here! Dummy return to keep some compilers happy.
  1712.       char * _result= 0;
  1713.       return _result;
  1714.     }
  1715.  
  1716.     ULong member_count () const {
  1717.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1718.       // never reach here! Dummy return to keep some compilers happy.
  1719.       ULong _result = 0;
  1720.       return _result;
  1721.     }
  1722.  
  1723.     const char* member_name(ULong index) const {
  1724.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1725.       // never reach here! Dummy return to keep some compilers happy.
  1726.       char * _result= 0;
  1727.       return _result;
  1728.     }
  1729.  
  1730.     TypeCode_ptr member_type(ULong index) const {
  1731.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1732.       // never reach here! Dummy return to keep some compilers happy.
  1733.       TypeCode_ptr _result= 0;
  1734.       return _result;
  1735.     }
  1736.  
  1737.     Any* member_label(ULong index) const {
  1738.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1739.       // never reach here! Dummy return to keep some compilers happy.
  1740.       Any * _result= 0;
  1741.       return _result;
  1742.     }
  1743.  
  1744.     TypeCode_ptr discriminator_type() const {
  1745.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1746.       // never reach here! Dummy return to keep some compilers happy.
  1747.       TypeCode_ptr _result= 0;
  1748.       return _result;
  1749.     }
  1750.  
  1751.     Long  default_index() const {
  1752.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1753.       // never reach here! Dummy return to keep some compilers happy.
  1754.       Long _result = 0;
  1755.       return _result;
  1756.     }
  1757.  
  1758.     ULong length() const {
  1759.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1760.       // never reach here! Dummy return to keep some compilers happy.
  1761.       ULong _result = 0;
  1762.       return _result;
  1763.     }
  1764.  
  1765.     TypeCode_ptr content_type() const {
  1766.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1767.       // never reach here! Dummy return to keep some compilers happy.
  1768.       TypeCode_ptr _result= 0;
  1769.       return _result;
  1770.     }
  1771.  
  1772.     Long param_count() const {
  1773.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1774.       // never reach here! Dummy return to keep some compilers happy.
  1775.       Long _result = 0;
  1776.       return _result;
  1777.     }
  1778.  
  1779.     Any* parameter(Long index) const {
  1780.       throw CORBA::BAD_OPERATION(0,CORBA::COMPLETED_NO);
  1781.       // never reach here! Dummy return to keep some compilers happy.
  1782.       Any * _result= 0;
  1783.       return _result;
  1784.     }
  1785.   };
  1786.  
  1787.  
  1788.  
  1789.   class TypeCode_INOUT_arg;
  1790.   class TypeCode_OUT_arg;
  1791.  
  1792.  
  1793.   class TypeCode_var {
  1794.   public:
  1795.     inline TypeCode_var() { pd_TC = CORBA::TypeCode::_nil(); }
  1796.  
  1797.     inline TypeCode_var(TypeCode_ptr p) { pd_TC = p; }
  1798.  
  1799.     inline TypeCode_var(const TypeCode_var& p) { 
  1800.     pd_TC = CORBA::TypeCode::_duplicate(p.pd_TC); 
  1801.     }
  1802.  
  1803.     inline ~TypeCode_var() { CORBA::release(pd_TC); }
  1804.  
  1805.     TypeCode_var(const TypeCode_member& p) { 
  1806.       pd_TC = CORBA::TypeCode::_duplicate(p._ptr);
  1807.     }
  1808.  
  1809.     inline TypeCode_var& operator= (TypeCode_ptr p) {
  1810.       CORBA::release(pd_TC);
  1811.       pd_TC = p;
  1812.       return *this;
  1813.     }
  1814.  
  1815.     inline TypeCode_var& operator= (const TypeCode_var& p) {
  1816.       if (this != &p)
  1817.     {
  1818.       CORBA::release(pd_TC);
  1819.       pd_TC = CORBA::TypeCode::_duplicate(p.pd_TC);
  1820.     }
  1821.       return *this;
  1822.     }
  1823.  
  1824.     inline TypeCode_var& operator=(const TypeCode_member& p) {
  1825.       CORBA::release(pd_TC);
  1826.       pd_TC = CORBA::TypeCode::_duplicate(p._ptr);
  1827.       return *this;
  1828.     }
  1829.       
  1830.  
  1831.     inline TypeCode_ptr operator->() const { return (TypeCode_ptr) pd_TC; }
  1832.     
  1833.     inline operator TypeCode_ptr() const { return pd_TC; }
  1834.  
  1835.     friend class TypeCode_member;
  1836.     friend class TypeCode_INOUT_arg;
  1837.     friend class TypeCode_OUT_arg;
  1838.  
  1839.   private:
  1840.     TypeCode_ptr pd_TC;
  1841.   };
  1842.  
  1843.  
  1844.  
  1845.   class TypeCode_INOUT_arg {
  1846.   public:
  1847.     inline TypeCode_INOUT_arg(TypeCode_ptr& p) : _data(p) { }
  1848.     inline TypeCode_INOUT_arg(TypeCode_var& p) : _data(p.pd_TC) { }
  1849.     inline TypeCode_INOUT_arg(TypeCode_member& p) : _data(p._ptr) { }
  1850.     inline ~TypeCode_INOUT_arg() { }
  1851.  
  1852.     TypeCode_ptr& _data;
  1853.  
  1854.   private:
  1855.     TypeCode_INOUT_arg();
  1856.   };
  1857.  
  1858.  
  1859.   class TypeCode_OUT_arg {
  1860.   public:
  1861.     TypeCode_OUT_arg(TypeCode_ptr& p) : _data(p) { }
  1862.     TypeCode_OUT_arg(TypeCode_var& p) : _data(p.pd_TC) {
  1863.       p = CORBA::TypeCode::_nil();
  1864.     }
  1865.     inline TypeCode_OUT_arg(TypeCode_member& p) : _data(p._ptr) {
  1866.       p = CORBA::TypeCode::_nil();
  1867.     }
  1868.     inline ~TypeCode_OUT_arg() { }
  1869.     
  1870.     TypeCode_ptr& _data;
  1871.  
  1872.   private:
  1873.     TypeCode_OUT_arg();
  1874.   };
  1875.  
  1876.  
  1877. ////////////////////////////////////////////////////////////////////////
  1878. //                   PIDL Request                                     //
  1879. ////////////////////////////////////////////////////////////////////////
  1880.  
  1881.   class Request {
  1882.   public:
  1883.     Object_ptr target() const;
  1884.     const char *operation() const;
  1885.     NVList_ptr arguments();
  1886.     NamedValue_ptr result();
  1887.     Environment_ptr env();
  1888.     ExceptionList_ptr exceptions();
  1889.     ContextList_ptr contexts();
  1890.  
  1891.     void ctx(Context_ptr);
  1892.     Context_ptr ctxt() const;
  1893.  
  1894.     Status invoke();
  1895.     Status send_oneway();
  1896.     Status send_deferred();
  1897.     Status get_response();
  1898.     Boolean poll_response();
  1899.  
  1900.     static Request_ptr _duplicate();
  1901.     static Request_ptr _nil();
  1902.   private:
  1903.     Request(); // Not implemented yet
  1904.   };
  1905.  
  1906. ////////////////////////////////////////////////////////////////////////
  1907. //                   PIDL BOA                                         //
  1908. ////////////////////////////////////////////////////////////////////////
  1909.  
  1910.   class BOA;
  1911.   typedef class BOA *BOA_ptr;
  1912.   typedef BOA_ptr BOARef;
  1913.  
  1914.   class BOA {
  1915.   public:
  1916.     Object_ptr create( const ReferenceData&,
  1917.                    InterfaceDef_ptr,
  1918.                    ImplementationDef_ptr) ;
  1919.     ReferenceData *get_id(Object_ptr) ;
  1920.     void change_implementation(Object_ptr,ImplementationDef_ptr) ;
  1921.     Principal_ptr get_principal(Object_ptr, Environment_ptr) ;
  1922.     void deactivate_impl(ImplementationDef_ptr) ;
  1923.     void deactivate_obj(Object_ptr) ;
  1924.  
  1925.     void dispose(Object_ptr) ;
  1926.     // see omni::disposeObject()
  1927.  
  1928.     void impl_is_ready(ImplementationDef_ptr=0,Boolean NonBlocking=0);
  1929.     // The argument <NonBlocking> is omniORB2 specific.
  1930.     // Calling this function will cause the BOA to start accepting requests
  1931.     // from other address spaces. 
  1932.  
  1933.     void impl_shutdown();
  1934.     // omniORB2 specific.
  1935.     // This is the reverse of impl_is_ready().
  1936.     // When this call returns, all the internal threads and network
  1937.     // connections will be shutdown. 
  1938.     // Any thread blocking on impl_is_ready is unblocked.
  1939.     // When this call returns, requests from other address spaces will not
  1940.     // be dispatched.
  1941.     // The BOA can be reactivated by impl_is_ready(), it will continue to use 
  1942.     // the existing network addresses when reactivated.
  1943.     //
  1944.     // Note: This function should not be called in the implementation of a
  1945.     //       CORBA interface. Otherwise, this call will be blocked 
  1946.     //       indefinitely waiting on itself to complete the request.
  1947.  
  1948.  
  1949.     void destroy();
  1950.     // omniORB2 specific.
  1951.     // Calling this function will destroy this BOA. The function will call
  1952.     // impl_shutdown() implicitly if it has not been called. When this call
  1953.     // returns, the network addresses (endpoints) where this BOA listens on
  1954.     // will be freed.
  1955.     // Note: After this call, the BOA should not be used directly or
  1956.     //       indirectly, otherwise the behaviour is undefined. If there is
  1957.     //       any object implementation still registered with the BOA when this
  1958.     //       function is called, the object implementation should not be called
  1959.     //       afterwards. This function does not call the dispose method of
  1960.     //       the implementations.
  1961.     // Note: Initialisation of another BOA using ORB::BOA_init() is not 
  1962.     //       supported. The behaviour of ORB::BOA_init() after this function 
  1963.     //       is called is undefined.
  1964.  
  1965.     void obj_is_ready(Object_ptr, ImplementationDef_ptr p=0);
  1966.  
  1967.     static BOA_ptr _duplicate(BOA_ptr);
  1968.     static BOA_ptr _nil();
  1969.  
  1970.     static BOA_ptr getBOA();
  1971.     // omniORB2 specific. Must be called after BOA_init is called.
  1972.     // Otherwise a CORBA::OBJ_ADAPTOR exception is raised.
  1973.  
  1974.     BOA();
  1975.     ~BOA();
  1976.   };
  1977.  
  1978. ////////////////////////////////////////////////////////////////////////
  1979. //                   PIDL ORB                                         //
  1980. ////////////////////////////////////////////////////////////////////////
  1981.  
  1982.   class ORB;
  1983.   typedef class ORB *ORB_ptr;
  1984.   typedef ORB_ptr ORBRef;
  1985.  
  1986.   class ORB  {
  1987.   public:
  1988.  
  1989.     char *object_to_string(Object_ptr) ;
  1990.     Object_ptr string_to_object(const char *) ;
  1991.  
  1992. #if defined(SUPPORT_DII)
  1993.     typedef sequence<Request_ptr> RequestSeq;
  1994.      Status create_list(Long, NVList_ptr&) ;
  1995.      Status create_operation_list(OperationDef_ptr, NVList_ptr&) ;
  1996.      Status create_named_value(NamedValue_ptr&) ;
  1997.      Status create_exception_list(ExceptionList_ptr&) ;
  1998.      Status create_context_list(ContextList_ptr&) ;
  1999.     
  2000.      Status get_default_context(Context_ptr&) ;
  2001.      Status create_environment(Environment_ptr&) ;
  2002.     
  2003.      Status send_multiple_requests_oneway(const RequestSeq&) ;
  2004.      Status send_multiple_requests_deferred(const RequestSeq&) ;
  2005.      Boolean poll_next_response() ;
  2006.      Status get_next_response(Request_ptr&) ;
  2007. #endif // SUPPORT_DII
  2008.  
  2009.     typedef char *OAid;
  2010.     
  2011.     BOA_ptr BOA_init(int &argc, char **argv, const char *boa_identifier=0) ;
  2012.  
  2013.     // Initial Object Reference definitions:
  2014.  
  2015.     typedef char* ObjectId;
  2016.     typedef String_var ObjectId_var;
  2017.  
  2018.     typedef _CORBA_Unbounded_Sequence<String_member > ObjectIdList;
  2019.  
  2020.     class ObjectIdList_OUT_arg;
  2021.  
  2022.     class ObjectIdList_var {
  2023.     public:
  2024.       typedef ObjectIdList* ptr_t;
  2025.       inline ObjectIdList_var() { pd_data = 0; }
  2026.       inline ObjectIdList_var(ObjectIdList* p) { pd_data = p; }
  2027.       inline ObjectIdList_var(const ObjectIdList_var& p) {
  2028.     if (!p.pd_data) {
  2029.       pd_data = 0;
  2030.       return;
  2031.     }
  2032.     else {
  2033.       pd_data = new ObjectIdList;
  2034.       if (!pd_data) {
  2035.         _CORBA_new_operator_return_null();
  2036.         // never reach here
  2037.       }
  2038.       *pd_data = *p.pd_data;
  2039.     }
  2040.       }
  2041.       inline ~ObjectIdList_var() {  if (pd_data) delete pd_data; }
  2042.       inline ObjectIdList_var& operator= (ObjectIdList* p) {
  2043.     if (pd_data) delete pd_data;
  2044.     pd_data = p;
  2045.     return *this;
  2046.       }
  2047.       inline ObjectIdList_var& operator= (const ObjectIdList_var& p) {
  2048.     if (p.pd_data) {
  2049.       if (!pd_data) {
  2050.         pd_data = new ObjectIdList;
  2051.         if (!pd_data) {
  2052.           _CORBA_new_operator_return_null();
  2053.           // never reach here
  2054.         }
  2055.       }
  2056.       *pd_data = *p.pd_data;
  2057.     }
  2058.     else {
  2059.       if (pd_data) delete pd_data;
  2060.       pd_data = 0;
  2061.     }
  2062.     return *this;
  2063.       }
  2064.       inline ObjectIdList* operator->() const { return pd_data; }
  2065.  
  2066. #if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
  2067.       inline operator ObjectIdList& () const { return *pd_data; }
  2068. #else
  2069.       inline operator const ObjectIdList& () const { return *pd_data; }
  2070.       inline operator ObjectIdList& () { return *pd_data; }
  2071. #endif
  2072.  
  2073.       friend class ObjectIdList_OUT_arg;
  2074.  
  2075.     private:
  2076.       ObjectIdList* pd_data;
  2077.     };
  2078.  
  2079.     // omniORB2 private class
  2080.     class ObjectIdList_OUT_arg {
  2081.     public:
  2082.       inline ObjectIdList_OUT_arg(ObjectIdList*& p) : _data(p) {}
  2083.       inline ObjectIdList_OUT_arg(ObjectIdList_var& p) : _data(p.pd_data) {
  2084.     p = (ObjectIdList*)0;
  2085.       }
  2086.       ObjectIdList*& _data;
  2087.     private:
  2088.       ObjectIdList_OUT_arg();
  2089.     };
  2090.  
  2091.     class InvalidName : public UserException {
  2092.     public:
  2093.  
  2094.       inline InvalidName() { }
  2095.       InvalidName(const InvalidName &);
  2096.  
  2097.       InvalidName & operator=(const InvalidName &);
  2098.       virtual ~InvalidName() { }
  2099.       size_t NP_alignedSize(size_t initialoffset);
  2100.       void operator>>= (NetBufferedStream &);
  2101.       void operator<<= (NetBufferedStream &);
  2102.       void operator>>= (MemBufferedStream &);
  2103.       void operator<<= (MemBufferedStream &);
  2104.     };
  2105.  
  2106.     ObjectIdList* list_initial_services() ;
  2107.     Object_ptr resolve_initial_references(const char *identifier) ;
  2108.  
  2109.     TypeCode_ptr 
  2110.     create_struct_tc(const char* id, const char* name, 
  2111.                   const StructMemberSeq& members);
  2112.  
  2113.     TypeCode_ptr 
  2114.     create_union_tc(const char* id, const char* name, 
  2115.           TypeCode_ptr discriminator_type, const UnionMemberSeq& members);
  2116.  
  2117.     
  2118.     TypeCode_ptr 
  2119.     create_enum_tc(const char* id, const char* name, 
  2120.                   const EnumMemberSeq& members);
  2121.  
  2122.     TypeCode_ptr 
  2123.     create_alias_tc(const char* id, const char* name, 
  2124.                   TypeCode_ptr original_type);
  2125.  
  2126.     TypeCode_ptr 
  2127.     create_exception_tc(const char* id, const char* name, 
  2128.                   const StructMemberSeq& members);
  2129.  
  2130.     TypeCode_ptr 
  2131.     create_interface_tc(const char* id, const char* name);
  2132.  
  2133.     TypeCode_ptr 
  2134.     create_string_tc(ULong bound);
  2135.  
  2136.     TypeCode_ptr 
  2137.     create_sequence_tc(ULong bound, TypeCode_ptr element_type);
  2138.  
  2139.     TypeCode_ptr 
  2140.     create_array_tc(ULong length, TypeCode_ptr element_type);
  2141.  
  2142.     TypeCode_ptr
  2143.     create_recursive_sequence_tc(ULong bound, ULong offset);
  2144.  
  2145.  
  2146.     static ORB_ptr _duplicate(ORB_ptr p);
  2147.     static ORB_ptr _nil();
  2148.  
  2149.     ORB();
  2150.     ~ORB();
  2151.  
  2152.   };
  2153.  
  2154.   typedef char *ORBid;
  2155.   static ORB_ptr ORB_init(int &argc, char **argv, const char *orb_identifier);
  2156.  
  2157. ////////////////////////////////////////////////////////////////////////
  2158. //                   PIDL release and is_null                         //
  2159. ////////////////////////////////////////////////////////////////////////
  2160.  
  2161.   static inline Boolean is_nil(TypeCode_ptr o) { return (o) ? o->NP_is_nil() 
  2162.                                     : 1; }
  2163.   static Boolean is_nil(Environment_ptr);
  2164.   static Boolean is_nil(Context_ptr);
  2165.   static Boolean is_nil(Principal_ptr);
  2166.   static inline Boolean is_nil(Object_ptr o) { 
  2167.     if (o)
  2168.       return o->NP_is_nil(); 
  2169.     else {
  2170.       // omniORB2 does not use a nil pointer to represent a nil object 
  2171.       // reference. The program has passed in a pointer which has not
  2172.       // been initialised by CORBA::Object::_nil() or similar functions.
  2173.       // Some ORBs seems to be quite lax about this. We don't want to
  2174.       // break the applications that make this assumption. Just call
  2175.       // _CORBA_use_nil_ptr_as_nil_objref() to take note of this.
  2176.       return _CORBA_use_nil_ptr_as_nil_objref();
  2177.     }
  2178.   }
  2179.   static Boolean is_nil(BOA_ptr p);
  2180.   static Boolean is_nil(ORB_ptr p);
  2181.   static Boolean is_nil(NamedValue_ptr);
  2182.   static Boolean is_nil(NVList_ptr);
  2183.   static Boolean is_nil(Request_ptr);
  2184.  
  2185.   static inline void release(TypeCode_ptr o) {
  2186.     if (!CORBA::is_nil(o)) delete o;
  2187.   }
  2188.  
  2189.   static void release(Environment_ptr);
  2190.   static void release(Context_ptr);
  2191.   static void release(Principal_ptr);
  2192.   static inline void release(Object_ptr o) 
  2193.   { 
  2194.     // see also omni::objectRelease()
  2195.     if (!CORBA::is_nil(o))
  2196.       o->NP_release(); 
  2197.     return;
  2198.   }
  2199.   static void release(BOA_ptr);
  2200.   static void release(ORB_ptr);
  2201.   static void release(NamedValue_ptr);
  2202.   static void release(NVList_ptr);
  2203.   static void release(Request_ptr);
  2204.  
  2205.   // omniORB2 private function.
  2206.   static Object_ptr UnMarshalObjRef(const char *repoId, NetBufferedStream &s); 
  2207.  
  2208.   // omniORB2 private function.
  2209.   static void MarshalObjRef(Object_ptr obj,
  2210.                 const char *repoId,
  2211.                 size_t repoIdSize,
  2212.                 NetBufferedStream &s);
  2213.  
  2214.   // omniORB2 private function
  2215.   static size_t AlignedObjRef(Object_ptr obj,
  2216.                   const char *repoId,
  2217.                   size_t repoIdSize,
  2218.                   size_t initialoffset);
  2219.  
  2220.   // omniORB2 private function
  2221.   static Object_ptr UnMarshalObjRef(const char *repoId,
  2222.                     MemBufferedStream &s);
  2223.  
  2224.   // omniORB2 private function
  2225.   static void MarshalObjRef(Object_ptr obj,
  2226.                 const char *repoId,
  2227.                 size_t repoIdSize,
  2228.                 MemBufferedStream &s);
  2229.  
  2230.   class Object_member;
  2231.   class Object_INOUT_arg;
  2232.   class Object_OUT_arg;
  2233.  
  2234.   class Object_var {
  2235.   public:
  2236.     inline Object_var() { pd_objref = CORBA::Object::_nil(); }
  2237.     inline Object_var(Object_ptr p) { pd_objref = p; }
  2238.     inline ~Object_var() {  
  2239.       if (!CORBA::is_nil(pd_objref)) CORBA::release(pd_objref);
  2240.     }
  2241.     inline Object_var(const Object_var& p) {
  2242.       if (!CORBA::is_nil(p.pd_objref)) {
  2243.     pd_objref = CORBA::Object::_duplicate(p.pd_objref);
  2244.       }
  2245.       else
  2246.     pd_objref = CORBA::Object::_nil();
  2247.     }
  2248.     Object_var(const Object_member& p);
  2249.     inline Object_var& operator= (Object_ptr p) {
  2250.       if (!CORBA::is_nil(pd_objref)) CORBA::release(pd_objref);
  2251.       pd_objref = p;
  2252.       return *this;
  2253.     }
  2254.     inline Object_var& operator= (const Object_var& p) {
  2255.       if (!CORBA::is_nil(pd_objref)) CORBA::release(pd_objref);
  2256.       if (!CORBA::is_nil(p.pd_objref)) {
  2257.     pd_objref = CORBA::Object::_duplicate(p.pd_objref);
  2258.       }
  2259.       else
  2260.     pd_objref = CORBA::Object::_nil();
  2261.       return *this;
  2262.     }
  2263.     Object_var& operator= (const Object_member& p);
  2264.     inline Object_ptr operator->() const { return (Object_ptr)pd_objref; }
  2265.  
  2266.     inline operator Object_ptr() const { return pd_objref; }
  2267.  
  2268.     friend class Object_member;
  2269.     friend class Object_INOUT_arg;
  2270.     friend class Object_OUT_arg;
  2271.  
  2272. private:
  2273.     Object_ptr pd_objref;
  2274.   };
  2275.   
  2276.   // omniORB2 private class
  2277.   class Object_member {
  2278.   public:
  2279.     inline Object_member() { _ptr = CORBA::Object::_nil(); }
  2280.     inline Object_member(Object_ptr p) { _ptr = p; }
  2281.     inline Object_member(const Object_member& p) {
  2282.       if (!CORBA::is_nil(p._ptr)) {
  2283.     _ptr = CORBA::Object::_duplicate(p._ptr);
  2284.       }
  2285.       else
  2286.     _ptr = CORBA::Object::_nil();
  2287.     }
  2288.     inline ~Object_member() {
  2289.       if (!CORBA::is_nil(_ptr)) CORBA::release(_ptr);
  2290.     }
  2291.     inline Object_member& operator= (Object_ptr p) {
  2292.       if (!CORBA::is_nil(_ptr)) CORBA::release(_ptr);
  2293.       _ptr = p;
  2294.       return *this;
  2295.     }
  2296.     inline Object_member& operator= (const Object_member& p) {
  2297.       if (!CORBA::is_nil(_ptr)) CORBA::release(_ptr);
  2298.       if (!CORBA::is_nil(p._ptr)) {
  2299.     _ptr = CORBA::Object::_duplicate(p._ptr);
  2300.       }
  2301.       else
  2302.     _ptr = CORBA::Object::_nil();
  2303.       return *this;
  2304.     }
  2305.     inline Object_member& operator= (const Object_var& p) {
  2306.       if (!CORBA::is_nil(_ptr)) CORBA::release(_ptr);
  2307.       if (!CORBA::is_nil(p.pd_objref)) {
  2308.     _ptr = CORBA::Object::_duplicate(p.pd_objref);
  2309.       }
  2310.       else
  2311.     _ptr = CORBA::Object::_nil();
  2312.       return *this;
  2313.     }
  2314.     inline size_t NP_alignedSize(size_t initialoffset) const {
  2315.       return CORBA::Object_Helper::NP_alignedSize(_ptr,initialoffset);
  2316.     }
  2317.     inline void operator>>= (NetBufferedStream &s) const {
  2318.       CORBA::Object_Helper::marshalObjRef(_ptr,s);
  2319.     }
  2320.     inline void operator<<= (NetBufferedStream &s) {
  2321.       Object_ptr _result = CORBA::Object_Helper::unmarshalObjRef(s);
  2322.       CORBA::release(_ptr);
  2323.       _ptr = _result;
  2324.     }
  2325.     inline void operator>>= (MemBufferedStream &s) const {
  2326.       CORBA::Object_Helper::marshalObjRef(_ptr,s);
  2327.     }
  2328.     inline void operator<<= (MemBufferedStream &s) {
  2329.       Object_ptr _result = CORBA::Object_Helper::unmarshalObjRef(s);
  2330.       CORBA::release(_ptr);
  2331.       _ptr = _result;
  2332.     }
  2333.  
  2334.     inline Object_ptr operator->() const { return (Object_ptr)_ptr; }
  2335.     inline operator Object_ptr () const { return _ptr; }
  2336.     Object_ptr _ptr;
  2337.   };
  2338.  
  2339.   // omniORB2 private class
  2340.   class Object_INOUT_arg {
  2341.   public:
  2342.     inline Object_INOUT_arg(Object_ptr& p) : _data(p) {}
  2343.     inline Object_INOUT_arg(Object_var& p) : _data(p.pd_objref) {}
  2344.     inline Object_INOUT_arg(Object_member& p) : _data(p._ptr) {}
  2345.     inline ~Object_INOUT_arg() {}
  2346.  
  2347.     Object_ptr& _data;
  2348.  
  2349.   private:
  2350.     Object_INOUT_arg();
  2351.   };
  2352.  
  2353.   // omniORB2 private class
  2354.   class Object_OUT_arg {
  2355.   public:
  2356.     inline Object_OUT_arg(Object_ptr& p) : _data(p) { }
  2357.     inline Object_OUT_arg(Object_var& p) : _data(p.pd_objref) { 
  2358.       p = CORBA::Object::_nil(); 
  2359.     }
  2360.     inline Object_OUT_arg(Object_member& p) : _data(p._ptr) { 
  2361.       p = CORBA::Object::_nil();
  2362.     }
  2363.     inline ~Object_OUT_arg() {}
  2364.  
  2365.     Object_ptr& _data;
  2366.  
  2367.   private:
  2368.     Object_OUT_arg();
  2369.   };
  2370.  
  2371.   class BOA_var {
  2372.   public:
  2373.     inline BOA_var() : pd_boaref(BOA::_nil()) {}
  2374.     inline BOA_var(BOA_ptr p) { pd_boaref = p; }
  2375.     inline ~BOA_var() {
  2376.       if (!CORBA::is_nil(pd_boaref)) {
  2377.     CORBA::release(pd_boaref);
  2378.       }
  2379.     }
  2380.     inline BOA_var(const BOA_var& p) { 
  2381.       pd_boaref = BOA::_duplicate(p.pd_boaref); 
  2382.     }
  2383.     inline BOA_var& operator= (BOA_ptr p) {
  2384.       if (!CORBA::is_nil(pd_boaref)) {
  2385.     CORBA::release(pd_boaref);
  2386.       }
  2387.       pd_boaref = p; 
  2388.       return *this; 
  2389.     }
  2390.     inline BOA_var& operator= (const BOA_var& p) {
  2391.       if (!CORBA::is_nil(pd_boaref)) {
  2392.     CORBA::release(pd_boaref);
  2393.       }
  2394.       pd_boaref = BOA::_duplicate(p.pd_boaref);
  2395.       return *this;
  2396.     }
  2397.     inline BOA_ptr operator->() const { return (BOA_ptr)pd_boaref; }
  2398.     inline operator BOA_ptr() const { return pd_boaref; }
  2399.  
  2400.   private:
  2401.     BOA_ptr pd_boaref;
  2402.   };
  2403.  
  2404.   class ORB_var {
  2405.   public:
  2406.     inline ORB_var() : pd_orbref(ORB::_nil()) {}
  2407.     inline ORB_var(ORB_ptr p) { pd_orbref = p; }
  2408.     inline ~ORB_var() {
  2409.       if (!CORBA::is_nil(pd_orbref)) {
  2410.     CORBA::release(pd_orbref);
  2411.       }
  2412.     }
  2413.     inline ORB_var(const ORB_var& p) { 
  2414.       pd_orbref = ORB::_duplicate(p.pd_orbref); 
  2415.     }
  2416.     inline ORB_var& operator= (ORB_ptr p) { 
  2417.       if (!CORBA::is_nil(pd_orbref)) {
  2418.     CORBA::release(pd_orbref);
  2419.       }
  2420.       pd_orbref = p; 
  2421.       return *this; 
  2422.     }
  2423.     inline ORB_var& operator= (const ORB_var& p) {
  2424.       if (!CORBA::is_nil(pd_orbref)) {
  2425.     CORBA::release(pd_orbref);
  2426.       }
  2427.       pd_orbref = ORB::_duplicate(p.pd_orbref);
  2428.       return *this;
  2429.     }
  2430.     inline ORB_ptr operator->() const { return (ORB_ptr)pd_orbref; }
  2431.     inline operator ORB_ptr() const { return pd_orbref; }
  2432.  
  2433.   private:
  2434.     ORB_ptr pd_orbref;
  2435.   };
  2436.  
  2437. };
  2438.  
  2439.  
  2440. #include <omniORB2/omniORB.h>
  2441. #include <omniORB2/templates.h>
  2442. #include <omniORB2/proxyFactory.h>
  2443.  
  2444. // omniORB2 private functions
  2445. extern CORBA::Boolean _omni_defaultTransientExceptionHandler(void* cookie,
  2446.                            CORBA::ULong n_retries,
  2447.                            const CORBA::TRANSIENT& ex);
  2448.  
  2449. extern CORBA::Boolean _omni_defaultCommFailureExceptionHandler(void* cookie,
  2450.                         CORBA::ULong n_retries,
  2451.                         const CORBA::COMM_FAILURE& ex);
  2452.  
  2453. extern CORBA::Boolean _omni_defaultSystemExceptionHandler(void* cookie,
  2454.                         CORBA::ULong n_retries,
  2455.                         const CORBA::SystemException& ex);
  2456.  
  2457. extern CORBA::Boolean _omni_callTransientExceptionHandler(omniObject*,
  2458.                         CORBA::ULong,
  2459.                         const CORBA::TRANSIENT&);
  2460. extern CORBA::Boolean _omni_callCommFailureExceptionHandler(omniObject*,
  2461.                           CORBA::ULong,
  2462.                           const CORBA::COMM_FAILURE&);
  2463. extern CORBA::Boolean _omni_callSystemExceptionHandler(omniObject*,
  2464.                          CORBA::ULong,
  2465.                          const CORBA::SystemException&);
  2466.  
  2467. // Include the COSS Naming Service header:
  2468. #include <omniORB2/Naming.hh>
  2469.  
  2470. #endif // __CORBA_H__
  2471.